// 变量可变性
// fn main() {
//     // let x = 5;
//     // mut 关键字让变量变为可变的
//     let mut x = 5;
//     println!("The value of x is: {}", x);
//     x = 6;
//     println!("The value of x is: {}", x);
// }

// 使用下划线开头忽略未使用的变量
// fn main() {
//     // 下划线开头的变量可以忽略未使用的变量
//     let _x = 5;
//     // 没有用下划线开头的变量，会被提醒未被使用
//     let y = 10;
// }

// 变量解构
// fn main() {
//     let (a, mut b): (bool,bool) = (true, false);
//     // a = true,不可变; b = false，可变
//     // println!("a = {:?}, b = {:?}", a, b);
//     println!("a = {}, b = {}", a, b);

//     b = true;
//     assert_eq!(a, b);
// }

// 解构式赋值
// struct Struct {
//     e: i32,
// }

// fn main() {
//     let (a, b, c, d, e);

//     (a, b) = (1, 2);
//     // _ 代表匹配一个值，但是我们不关心具体的值是什么，因此没有使用一个变量名而是使用了 _
//     [c, .., d, _] = [1, 2, 3, 4, 5];
//     Struct { e, .. } = Struct { e: 5 };

//     assert_eq!([1, 2, 1, 4, 5], [a, b, c, d, e]);
// }

// 常量不仅仅默认不可变，而且自始至终不可变
const _MAX_POINTS: u32 = 100_000;
const _MAX_POINTS_VALUE: i32 = 100_000;

// Rust 允许声明相同的变量名，在后面声明的变量会遮蔽掉前面声明的
// fn main() {
//     let x = 5;
//     // 在main函数的作用域内对之前的x进行遮蔽
//     let x = x + 1;

//     {
//         // 在当前的花括号作用域内，对之前的x进行遮蔽
//         let x = x * 2;
//         println!("The value of x in the inner scope is: {}", x);
//     }

//     println!("The value of x is: {}", x);
// }

// 练习题
// 练习题
// 练习题

// 1.修复下面代码的错误并尽可能少的修改
// fn main() {
//     let x: i32; // 未初始化，但被使用
//     let y: i32; // 未初始化，也未被使用
//     println!("x is equal to {}", x);
// }
// 解：
// fn main() {
//     let x: i32 = 2; // 未初始化，但被使用
//     let _y: i32 = 3; // 未初始化，也未被使用
//     println!("x is equal to {}", x);
// }

// 2.完形填空，让代码编译
// fn main() {
//     let __ = 1;
//     __ += 2;

//     println!("x = {}", x);
// }
// 解：
// fn main() {
//     let mut x = 1;
//     x += 2;
//     println!("x = {}", x);
// }

// 3.修复下面代码的错误并使用尽可能少的改变
// fn main() {
//     let x: i32 = 10;
//     {
//         let y: i32 = 5;
//         println!("x 的值是 {}, y 的值是 {}", x, y);
//     }
//     println!("x 的值是 {}, y 的值是 {}", x, y);
// }
// 解：
// fn main() {
//     let x: i32 = 10;
//     let y: i32 = 12;
//     {
//         let y: i32 = 5;
//         println!("x 的值是 {}, y 的值是 {}", x, y);
//     }
//     println!("x 的值是 {}, y 的值是 {}", x, y);
// }

// 4.修复错误
// fn main() {
//     println!("{}, world", x);
// }

// fn define_x() {
//     let x = "hello";
// }
// 解：
// fn main() {
//     define_x();
// }
// fn define_x() {
//     let x = "hello";
//     println!("{}, world", x);
// }
// 解2：
// fn main(){
//     let x = define_x();
//     println!("{},world", x)
// }
// fn define_x() -> String {
//     let x = "hello".to_string();
//     x
// }
// 解3：
// fn main(){
//     let x = define_x();
//     println!("{}, world", x);
// }
// fn define_x() -> &'static str {
//     let x = "hello";
//     x
// }

// 5.只允许修改 `assert_eq!` 来让 `println!` 工作(在终端输出 `42`)
// fn main() {
//     let x: i32 = 5;
//     {
//         let x = 12;
//         assert_eq!(x, 5);
//     }
//     assert_eq!(x, 12);
//     let x = 42;
//     println!("{}", x); // 输出 "42".
// }
// 解：
// fn main() {
//     let x: i32 = 5;
//     {
//         let x = 12;
//         assert_eq!(x, 12);
//     }
//     assert_eq!(x, 5);
//     let x = 42;
//     println!("{}", x); // 输出 "42".
// }

// 6.修改一行代码以通过编译
// fn main() {
//     let mut x: i32 = 1;
//     x = 7;
//     // 遮蔽且再次绑定
//     let x = x;
//     x += 3;
//     let y = 4;
//     // 遮蔽
//     let y = "I can also be bound to text!";
// }
// 解：
// fn main() {
//     let mut _x: i32 = 1;
//     _x = 7;
//     // 遮蔽且再次绑定
//     let mut _x = _x;
//     _x += 3;
//     let _y = 4;
//     // 遮蔽
//     let _y = "I can also be bound to text!";
// }

// 7.使用以下方法来修复编译器输出的 warning :
// fn main() {
//     let x = 1;
// }
// 解：
// fn main() {
//     // let _x = 1;
//     let x = 1;
//     println!("x:{}", x);
// }

// 8.修复下面代码的错误并尽可能少的修改
// fn main() {
//     let (x, y) = (1, 2);
//     x += 2;
//     assert_eq!(x, 3);
//     assert_eq!(y, 2);
// }
// 解：
// fn main() {
//     let (mut x, y) = (1, 2);
//     x += 2;
//     assert_eq!(x, 3);
//     assert_eq!(y, 2);
// }


// 9.解构式赋值
// fn main() {
//     let (x, y);
//     (x,..) = (3, 4);
//     [.., y] = [1, 2];
//     // 填空，让代码工作
//     assert_eq!([x,y], __);
// }
// 解：
fn main() {
    let (x, y);
    (.., x) = (3, 4, 8);
    [.., y] = [1, 2, 0];
    // 填空，让代码工作
    assert_eq!([x, y], [8, 0]);
    println!("x:{},y:{}", x,y)
}
